using System;
using System.Collections;
using System.Data;
using BeeldBank.Business;
using BeeldBank.Business.Collection;
using BeeldBank.Toolkit;

namespace BeeldBank.Business.Base
{
    /// <summary>
    /// Provides database independant methods for MediaObject.
    /// </summary>
    public class MediaObjectBase : BusinessBase
    {
        internal MediaObjectBase(System.Data.DataRow row)
            : base(row)
        {
            this.OnPrepareForSave += new PrepareForSaveHandler(this.PrepareForSave);
        }

        public delegate void PrepareForSaveHandler();
        public event PrepareForSaveHandler OnPrepareForSave;

        #region property bool EnforceSave
        /// This property is used to indicate if the
        /// object in the save event should save, even
        /// if the object contents (marked as stereotype NOTENFORCESAVE) is not saved
        private bool _EnforceSave = false;
        public bool EnforceSave
        {
            get
            {
                return _EnforceSave;
            }
            set
            {
                _EnforceSave = value;
            }
        }
        #endregion

        #region PrepareForSaveBase()
        public void PrepareForSaveBase()
        {
            if (!this.PrepareForSaveFinished)
            {
                if (OnPrepareForSave != null)
                {
                    OnPrepareForSave();
                }
                this.CanLoad = false;
                // call prepareforsave on all dependant objects.
                if (this.Status != null)
                {
                    this.Status.PrepareForSaveBase();
                }
                if (this.Type != null)
                {
                    this.Type.PrepareForSaveBase();
                }
                if (this.WordItems != null)
                {
                    foreach (WordItem wordItem in this.WordItems)
                    {
                        wordItem.PrepareForSaveBase();
                    }
                }
                this.CanLoad = true;
                this.PrepareForSaveFinished = true;
            }
        }
        #endregion

        #region PrepareForSave()
        public virtual void PrepareForSave()
        {
        }
        #endregion

        #region PreSave()
        public virtual void PreSave()
        {
        }
        #endregion

        #region Save()
        public void Save()
        {
            bool IsSaveNeeded = ContentChanged();

            if (IsDirty)
            {
                this.ModifiedBy = _luw.UserName;
                if (this.State == BusinessState.New)
                {
                    this.CreatedBy = _luw.UserName;
                    if (this.Status != null)
                    {
                        this.Status.Save();
                    }
                    if (this.Type != null)
                    {
                        this.Type.Save();
                    }
                    BeeldBank.Data.MediaObject.Insert(this._dataRow, _luw.Transaction);
                    if (this.WordItems != null)
                    {
                        foreach (WordItem wordItem in this.WordItems)
                        {
                            wordItem.MediaObjectId = this.Id;
                        }
                    }
                }

                if ((this.State == BusinessState.Changed) && (IsSaveNeeded))
                {
                    BeeldBank.Data.MediaObject.Update(this._dataRow, _luw.Transaction);
                }

                if (this.State == BusinessState.Deleted)
                {
                    if (this.WordItems != null)
                    {
                        foreach (WordItem wordItem in this.WordItems)
                        {
                            wordItem.Save();
                        }
                    }
                    BeeldBank.Data.MediaObject.Delete(this._dataRow, _luw.Transaction);
                    if (this.Status != null)
                    {
                        this.Status.Save();
                    }
                    if (this.Type != null)
                    {
                        this.Type.Save();
                    }
                }
                IsDirty = false;
            }
        }
        #endregion

        #region OldMediaObject
        private MediaObject _oldMediaObject;
        public MediaObject OldMediaObject
        {
            get
            {
                if (_oldMediaObject == null && this.State != BusinessState.New)
                {
                    // Create the new object in a completely separate luw,
                    // otherwise a reference the the current object is returned.
                    Luw luw = new Luw(this.Luw.UserName);
                    _oldMediaObject = luw.NewMediaObject(BeeldBank.Data.MediaObject.Open(this.Id).Rows[0]);
                }
                return _oldMediaObject;
            }
        }
        #endregion

        #region Checked
        /// <summary>
        /// 
        /// </summary>
        public bool Checked
        {
            get
            {
                return (_dataRow["Checked"] == Convert.DBNull) ? false : Convert.ToBoolean(_dataRow["Checked"]);
            }
            set
            {
                _dataRow["Checked"] = value;
                this.IsDirty = true;
            }
        }
        #endregion

        #region Id
        /// <summary>
        /// 
        /// </summary>
        public int Id
        {
            get
            {
                return Convert.ToInt32(_dataRow["Id"]);
            }
            set
            {
                _dataRow["Id"] = value;
                this.IsDirty = true;
            }
        }
        public bool IdIsNull
        {
            get
            {
                return _dataRow["Id"] == Convert.DBNull;
            }
        }
        public void IdSetNull()
        {
            _dataRow["Id"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region StatusId
        /// <summary>
        /// Status van het media bestand
        /// </summary>
        public int StatusId
        {
            get
            {
                return Convert.ToInt32(_dataRow["StatusId"]);
            }
            set
            {
                _dataRow["StatusId"] = value;
                this.IsDirty = true;
            }
        }
        public bool StatusIdIsNull
        {
            get
            {
                return _dataRow["StatusId"] == Convert.DBNull;
            }
        }
        public void StatusIdSetNull()
        {
            _dataRow["StatusId"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region TypeId
        /// <summary>
        /// Het type media bestand (digitaal, analoog, video)
        /// </summary>
        public int TypeId
        {
            get
            {
                return Convert.ToInt32(_dataRow["TypeId"]);
            }
            set
            {
                _dataRow["TypeId"] = value;
                this.IsDirty = true;
            }
        }
        public bool TypeIdIsNull
        {
            get
            {
                return _dataRow["TypeId"] == Convert.DBNull;
            }
        }
        public void TypeIdSetNull()
        {
            _dataRow["TypeId"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Titel
        /// <summary>
        /// De titel van het media bestand
        /// </summary>
        public string Titel
        {
            get
            {
                return Convert.ToString(_dataRow["Titel"]);
            }
            set
            {
                _dataRow["Titel"] = value;
                this.IsDirty = true;
            }
        }
        public bool TitelIsNull
        {
            get
            {
                return _dataRow["Titel"] == Convert.DBNull;
            }
        }
        public void TitelSetNull()
        {
            _dataRow["Titel"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Omschrijving
        /// <summary>
        /// Omschrijving van het media bestand
        /// </summary>
        public string Omschrijving
        {
            get
            {
                return (_dataRow["Omschrijving"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["Omschrijving"]);
            }
            set
            {
                _dataRow["Omschrijving"] = value;
                this.IsDirty = true;
            }
        }
        public bool OmschrijvingIsNull
        {
            get
            {
                return _dataRow["Omschrijving"] == Convert.DBNull;
            }
        }
        public void OmschrijvingSetNull()
        {
            _dataRow["Omschrijving"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region AltTekst
        /// <summary>
        /// Alt Tekst van het media bestand
        /// </summary>
        public string AltTekst
        {
            get
            {
                return (_dataRow["AltTekst"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["AltTekst"]);
            }
            set
            {
                _dataRow["AltTekst"] = value;
                this.IsDirty = true;
            }
        }
        public bool AltTekstIsNull
        {
            get
            {
                return _dataRow["AltTekst"] == Convert.DBNull;
            }
        }
        public void AltTekstSetNull()
        {
            _dataRow["AltTekst"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Datum_Realisatie
        /// <summary>
        /// Datum waarop het media bestand in het veld gemaakt is.
        /// </summary>
        public DateTime Datum_Realisatie
        {
            get
            {
                return (_dataRow["Datum_Realisatie"] == Convert.DBNull) ? DateTime.Now : Convert.ToDateTime(_dataRow["Datum_Realisatie"]);
            }
            set
            {
                _dataRow["Datum_Realisatie"] = value;
                this.IsDirty = true;
            }
        }
        public bool Datum_RealisatieIsNull
        {
            get
            {
                return _dataRow["Datum_Realisatie"] == Convert.DBNull;
            }
        }
        public void Datum_RealisatieSetNull()
        {
            _dataRow["Datum_Realisatie"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Trefwoorden
        /// <summary>
        /// Lijst met trefwoorden die niet in de omschrijving passen.
        /// </summary>

        public string Trefwoorden
        {
            get
            {
                return (_dataRow["Trefwoorden"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["Trefwoorden"]);
            }
            set
            {
                _dataRow["Trefwoorden"] = value;
                this.IsDirty = true;
            }
        }
        public bool TrefwoordenIsNull
        {
            get
            {
                return _dataRow["Trefwoorden"] == Convert.DBNull;
            }
        }
        public void TrefwoordenSetNull()
        {
            _dataRow["Trefwoorden"] = Convert.DBNull;
            this.IsDirty = true;
        }

        #region TrefWoordBestaat
        public bool TrefWoordBestaat(string ChkWord)
        {
            /// <summary>
            /// Controleer of Trefwoord Bestaat
            /// </summary>
            DataTable table = BeeldBank.Data.Word.ShowFromWord(ChkWord);
            if (table.Rows.Count > 0)
            {
                return true;
            }
            else
                return false;
        }
        #endregion

        #region TrefWoordDelete
        public bool TrefWoordDelete(string ChkWord)
        {
            /// <summary>
            /// Geef aan of dit trefwoord verwijderd moet worden
            /// </summary>
            DataTable table = BeeldBank.Data.Word.ShowFromWord(ChkWord);
            if (table.Rows.Count > 0)
            {
                string CorrWord = table.Rows[0]["WordCorrection"].ToString();
                // Dit woord moet verwijderd worden
                if (CorrWord.CompareTo("0") == 0)
                    return true;
                else
                    return false;
            }
            else
                return false;
        }
        #endregion

        #region TrefWoordCorrectie
        public string TrefWoordCorrectie(string ChkWord)
        {
            /// <summary>
            /// Geef de string terug waarmee dit trefwoord gecorrigeerd moet worden
            /// </summary>
            DataTable table = BeeldBank.Data.Word.ShowFromWord(ChkWord);
            if (table.Rows.Count > 0)
            {
                string CorrWord = table.Rows[0]["WordCorrection"].ToString();
                // Indien er een correctie is, die ongelijk is aan 0 dan corrigeren
                if ((CorrWord.Length > 0) && (CorrWord.CompareTo("0") != 0))
                {
                    return CorrWord;
                }
                else
                    return table.Rows[0]["Word"].ToString();
            }
            else
                return ChkWord;
        }
        #endregion

        #region TrefWoordAlternatief
        public string TrefWoordAlternatief(string ChkWord)
        {
            /// <summary>
            /// Geef de alternatieve string voor dit trefwoord terug
            /// </summary>
            DataTable table = BeeldBank.Data.Word.ShowFromWord(ChkWord);
            if (table.Rows.Count > 0)
            {
                string AltWord = table.Rows[0]["WordAlternative"].ToString();
                if (AltWord.Length > 0)
                {
                    return AltWord;
                }
                else
                    return null;
            }
            else
                return null;
        }
        #endregion

        #region TrefWoordZoek
        public UniqueStringList TrefWoordZoek(string Titel, string Omschrijving, string Trefwoorden)
        {
            /// <summary>
            /// Retourneer de Trefwoorden gebaseerd op Titel, Omschrijving en bestaande trefwoorden
            /// </summary>
            UniqueStringList myWords = new UniqueStringList();

            string[] split = Titel.Split(new Char[] { ' ', ',', '.', ':', '<', '>', '-', '~', '_', '+', '|', '!', '?' });
            foreach (string s in split)
            {
                string TekstFragment = s.Trim();
                if (TekstFragment != "")
                {
                    try
                    {
                        // Filter losse getallen weg uit de trefwoorden lijst
                        int value = Int32.Parse(TekstFragment);
                    }
                    catch
                    {
                        if (TekstFragment.Length > 1)
                        {
                            // Als dit een juist trefwoord is en niet verwijderd hoeft te worden
                            // dan de gecorrigeerde versie toevoegen
                            // en het alternatief toevoegen
                            if (TrefWoordBestaat(TekstFragment) && !TrefWoordDelete(TekstFragment))
                            {
                                myWords.Add(TrefWoordCorrectie(TekstFragment));
                                myWords.Add(TrefWoordAlternatief(TekstFragment));
                            }
                        }
                    }
                }
            }
            split = Trefwoorden.Split(new Char[] { '|' });
            foreach (string s in split)
            {
                if (s.Trim() != "")
                {
                    // Behandel de (snel)wegen apart
                    string TekstFragment = s.Trim();
                    if (TekstFragment.StartsWith("N ") || TekstFragment.StartsWith("A ") || TekstFragment.StartsWith("E ") || TekstFragment.StartsWith("RW "))
                    {
                        TekstFragment = s.Replace(" ", "");
                    }
                    if (TekstFragment.Length > 1)
                    {
                        try
                        {
                            // Filter losse getallen weg uit de trefwoorden lijst
                            int value = Int32.Parse(TekstFragment);
                        }
                        catch
                        {
                            if (TekstFragment.Length > 1)
                            {
                                // Alle trefwoorden worden nu standaard toegevoegd
                                // tenzij deze verwijderd moet worden
                                if (!TrefWoordDelete(TekstFragment))
                                {
                                    myWords.Add(TrefWoordCorrectie(TekstFragment));
                                    myWords.Add(TrefWoordAlternatief(TekstFragment));
                                }
                            }
                        }
                    }
                }
            }
            split = Omschrijving.Split(new Char[] { ' ', ',', '.', ':', ';', '(', ')', '<', '>', '-', '_', '|', '!', '?', '~', '+', '/', '\'', '"', '\n', '\r' });
            foreach (string s in split)
            {
                if (s.Trim() != "")
                {
                    // Behandel de (snel)wegen apart
                    string TekstFragment = s.Trim();
                    if (TekstFragment.StartsWith("N ") || TekstFragment.StartsWith("A ") || TekstFragment.StartsWith("E ") || TekstFragment.StartsWith("RW "))
                    {
                        TekstFragment = s.Replace(" ", "");
                    }
                    if (TekstFragment.Length > 1)
                    {
                        try
                        {
                            // Filter losse getallen weg uit de trefwoorden lijst
                            int value = Int32.Parse(TekstFragment);
                        }
                        catch
                        {
                            if (TekstFragment.Length > 1)
                            {
                                // Als dit een juist trefwoord is en niet verwijderd hoeft te worden
                                // dan de gecorrigeerde versie toevoegen
                                // en het alternatief toevoegen
                                if (TrefWoordBestaat(TekstFragment) && !TrefWoordDelete(TekstFragment))
                                {
                                    myWords.Add(TrefWoordCorrectie(TekstFragment));
                                    myWords.Add(TrefWoordAlternatief(TekstFragment));
                                }
                            }
                        }
                    }
                }
            }

            myWords.Sort();

            // Retourneer de gesorteerde lijst
            return myWords;
        }
        #endregion

        #region GenerateTrefwoorden
        public void GenerateTrefwoorden()
        {
            BeeldBank.Toolkit.UniqueStringList myWords = new BeeldBank.Toolkit.UniqueStringList();

            string[] split = this.Titel.Split(new Char[] { ' ', ',', '.', ':', '<', '>', '-', '~', '_', '+', '|', '!', '?' });
            foreach (string s in split)
            {
                string TekstFragment = s.Trim();
                if (TekstFragment != "")
                {
                    try
                    {
                        // Filter losse getallen weg uit de trefwoorden lijst
                        int value = Int32.Parse(TekstFragment);
                    }
                    catch
                    {
                        if (TekstFragment.Length > 1)
                        {
                            // Als dit een juist trefwoord is en niet verwijderd hoeft te worden
                            // dan de gecorrigeerde versie toevoegen
                            // en het alternatief toevoegen
                            if (TrefWoordBestaat(TekstFragment) && !TrefWoordDelete(TekstFragment))
                            {
                                myWords.Add(TrefWoordCorrectie(TekstFragment));
                                myWords.Add(TrefWoordAlternatief(TekstFragment));
                                if (TekstFragment.CompareTo(TrefWoordCorrectie(TekstFragment)) != 0)
                                {
                                    // Corrigeer Titel
                                    this.Titel.Replace(TekstFragment, TrefWoordCorrectie(TekstFragment)).Trim();
                                }
                            }
                        }
                    }
                }
            }
            split = this.Trefwoorden.Split(new Char[] { '|' });
            foreach (string s in split)
            {
                if (s.Trim() != "")
                {
                    // Behandel de (snel)wegen apart
                    string TekstFragment = s.Trim();
                    if (TekstFragment.StartsWith("N ") || TekstFragment.StartsWith("A ") || TekstFragment.StartsWith("E ") || TekstFragment.StartsWith("RW "))
                    {
                        TekstFragment = s.Replace(" ", "");
                    }
                    if (TekstFragment.Length > 1)
                    {
                        try
                        {
                            // Filter losse getallen weg uit de trefwoorden lijst
                            int value = Int32.Parse(TekstFragment);
                        }
                        catch
                        {
                            if (TekstFragment.Length > 1)
                            {
                                // Alle trefwoorden worden nu standaard toegevoegd
                                // tenzij deze verwijderd moet worden
                                if (!TrefWoordDelete(TekstFragment))
                                {
                                    myWords.Add(TrefWoordCorrectie(TekstFragment));
                                    myWords.Add(TrefWoordAlternatief(TekstFragment));
                                }
                            }
                        }
                    }
                }
            }
            split = this.Omschrijving.Split(new Char[] { ' ', ',', '.', ':', ';', '(', ')', '<', '>', '-', '_', '|', '!', '?', '~', '+', '/', '\'', '"', '\n', '\r' });
            foreach (string s in split)
            {
                if (s.Trim() != "")
                {
                    // Behandel de (snel)wegen apart
                    string TekstFragment = s.Trim();
                    if (TekstFragment.StartsWith("N ") || TekstFragment.StartsWith("A ") || TekstFragment.StartsWith("E ") || TekstFragment.StartsWith("RW "))
                    {
                        TekstFragment = s.Replace(" ", "");
                    }
                    if (TekstFragment.Length > 1)
                    {
                        try
                        {
                            // Filter losse getallen weg uit de trefwoorden lijst
                            int value = Int32.Parse(TekstFragment);
                        }
                        catch
                        {
                            if (TekstFragment.Length > 1)
                            {
                                // Als dit een juist trefwoord is en niet verwijderd hoeft te worden
                                // dan de gecorrigeerde versie toevoegen
                                // en het alternatief toevoegen
                                if (TrefWoordBestaat(TekstFragment) && !TrefWoordDelete(TekstFragment))
                                {
                                    myWords.Add(TrefWoordCorrectie(TekstFragment));
                                    myWords.Add(TrefWoordAlternatief(TekstFragment));

                                    // Corrigeer Omschrijving
                                    this.Omschrijving.Replace(TekstFragment, TrefWoordCorrectie(TekstFragment)).Trim();
                                }
                            }
                        }
                    }
                }
            }

            myWords.Sort();

            string NewTrefwoordString = "";

            foreach (string s in myWords)
            {
                NewTrefwoordString = NewTrefwoordString + s + " | ";
            }
            // Alleen het laatste scheidingsteken weghalen als de string gevuld is
            if (NewTrefwoordString.Length > 2) NewTrefwoordString = NewTrefwoordString.Substring(0, NewTrefwoordString.Length - 2);

            // Is er iets aan de trefwoorden veranderd?
            if (NewTrefwoordString.CompareTo(this.Trefwoorden) != 0)
            {
                this.TrefwoordenSetNull();
                this.Trefwoorden = NewTrefwoordString;
            }

        }
        #endregion
        #endregion

        #region WoordenZoeker
        public UniqueStringList WoordenZoeker(string Titel, string Omschrijving, string Trefwoorden)
        {
            /// <summary>
            /// Retourneer de Woorden uit de Titel, Omschrijving en bestaande trefwoorden
            /// </summary>
            UniqueStringList myWords = new UniqueStringList();

            string[] split = Titel.Split(new Char[] { ' ', ',', '.', ':', '<', '>', '~', '+', '|', '!', '?' });
            foreach (string s in split)
            {
                string TekstFragment = s.Trim();
                if (TekstFragment != "")
                {
                    try
                    {
                        if (TekstFragment.Length > 1)
                        {
                            myWords.Add(TekstFragment);
                        }
                    }
                    catch
                    {
                    }
                }
            }
            split = Trefwoorden.Split(new Char[] { '|' });
            foreach (string s in split)
            {
                string TekstFragment = s.Trim();
                if (TekstFragment != "")
                {
                    try
                    {
                        if (TekstFragment.Length > 1)
                        {
                            myWords.Add(TekstFragment);
                        }
                    }
                    catch
                    {
                    }
                }
            }
            split = Omschrijving.Split(new Char[] { ' ', ',', '.', ':', ';', '(', ')', '<', '>', '|', '!', '?', '~', '+', '/', '\'', '"', '\n', '\r' });
            foreach (string s in split)
            {
                string TekstFragment = s.Trim();
                if (TekstFragment != "")
                {
                    try
                    {
                        if (TekstFragment.Length > 1)
                        {
                            myWords.Add(TekstFragment);
                        }
                    }
                    catch
                    {
                    }
                }
            }

            myWords.Sort();

            // Retourneer de gesorteerde lijst
            return myWords;
        }
        #endregion

        #region Archiefnummer
        /// <summary>
        /// Nummer uit het archief
        /// </summary>
        public int Archiefnummer
        {
            get
            {
                return Convert.ToInt32(_dataRow["Archiefnummer"]);
            }
            set
            {
                _dataRow["Archiefnummer"] = value;
                this.IsDirty = true;
            }
        }
        public bool ArchiefnummerIsNull
        {
            get
            {
                return _dataRow["Archiefnummer"] == Convert.DBNull;
            }
        }
        public void ArchiefnummerSetNull()
        {
            _dataRow["Archiefnummer"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Subnummer
        /// <summary>
        /// Subnummer van de foto
        /// </summary>
        public int Subnummer
        {
            get
            {
                return (_dataRow["Subnummer"] == Convert.DBNull) ? 0 : Convert.ToInt32(_dataRow["Subnummer"]);
            }
            set
            {
                _dataRow["Subnummer"] = value;
                this.IsDirty = true;
            }
        }
        public bool SubnummerIsNull
        {
            get
            {
                return _dataRow["Subnummer"] == Convert.DBNull;
            }
        }
        public void SubnummerSetNull()
        {
            _dataRow["Subnummer"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Mapnummer
        /// <summary>
        /// Mapnummer van de foto
        /// </summary>
        public string Mapnummer
        {
            get
            {
                return (_dataRow["Mapnummer"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["Mapnummer"]);
            }
            set
            {
                _dataRow["Mapnummer"] = value;
                this.IsDirty = true;
            }
        }
        public bool MapnummerIsNull
        {
            get
            {
                return _dataRow["Mapnummer"] == Convert.DBNull;
            }
        }
        public void MapnummerSetNull()
        {
            _dataRow["Mapnummer"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Doosnummer
        /// <summary>
        /// Doosnummer van de foto
        /// </summary>
        public int Doosnummer
        {
            get
            {
                return (_dataRow["Doosnummer"] == Convert.DBNull) ? 0 : Convert.ToInt32(_dataRow["Doosnummer"]);
            }
            set
            {
                _dataRow["Doosnummer"] = value;
                this.IsDirty = true;
            }
        }
        public bool DoosnummerIsNull
        {
            get
            {
                return _dataRow["Doosnummer"] == Convert.DBNull;
            }
        }
        public void DoosnummerSetNull()
        {
            _dataRow["Doosnummer"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Hoesnummer
        /// <summary>
        /// Hoesnummer van de foto
        /// </summary>
        public int Hoesnummer
        {
            get
            {
                return (_dataRow["Hoesnummer"] == Convert.DBNull) ? 0 : Convert.ToInt32(_dataRow["Hoesnummer"]);
            }
            set
            {
                _dataRow["Hoesnummer"] = value;
                this.IsDirty = true;
            }
        }
        public bool HoesnummerIsNull
        {
            get
            {
                return _dataRow["Hoesnummer"] == Convert.DBNull;
            }
        }
        public void HoesnummerSetNull()
        {
            _dataRow["Hoesnummer"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Vervaardiger
        /// <summary>
        /// De vervaardiger van de beelden
        /// </summary>
        public string Vervaardiger
        {
            get
            {
                return (_dataRow["Vervaardiger"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["Vervaardiger"]);
            }
            set
            {
                _dataRow["Vervaardiger"] = value;
                this.IsDirty = true;
            }
        }
        public bool VervaardigerIsNull
        {
            get
            {
                return _dataRow["Vervaardiger"] == Convert.DBNull;
            }
        }
        public void VervaardigerSetNull()
        {
            _dataRow["Vervaardiger"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Montage
        /// <summary>
        /// Type montage
        /// </summary>
        public string Montage
        {
            get
            {
                return (_dataRow["Montage"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["Montage"]);
            }
            set
            {
                _dataRow["Montage"] = value;
                this.IsDirty = true;
            }
        }
        public bool MontageIsNull
        {
            get
            {
                return _dataRow["Montage"] == Convert.DBNull;
            }
        }
        public void MontageSetNull()
        {
            _dataRow["Montage"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Collectie
        /// <summary>
        /// Type Collectie
        /// </summary>
        public string Collectie
        {
            get
            {
                return (_dataRow["Collectie"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["Collectie"]);
            }
            set
            {
                _dataRow["Collectie"] = value;
                this.IsDirty = true;
            }
        }
        public bool CollectieIsNull
        {
            get
            {
                return _dataRow["Collectie"] == Convert.DBNull;
            }
        }
        public void CollectieSetNull()
        {
            _dataRow["Collectie"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region VideoLengte
        /// <summary>
        /// Lengte van de video.
        /// </summary>
        public DateTime VideoLengte
        {
            get
            {
                return (_dataRow["VideoLengte"] == Convert.DBNull) ? DateTime.Now : Convert.ToDateTime(_dataRow["VideoLengte"]);
            }
            set
            {
                _dataRow["VideoLengte"] = value;
                this.IsDirty = true;
            }
        }
        public bool VideoLengteIsNull
        {
            get
            {
                return _dataRow["VideoLengte"] == Convert.DBNull;
            }
        }
        public void VideoLengteSetNull()
        {
            _dataRow["VideoLengte"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region FileNummer
        /// <summary>
        /// De naam van het fysieke bestand op schijf.
        /// </summary>
        public int FileNummer
        {
            get
            {
                return (_dataRow["FileNummer"] == Convert.DBNull) ? 0 : Convert.ToInt32(_dataRow["FileNummer"]);
            }
            set
            {
                _dataRow["FileNummer"] = value;
                this.IsDirty = true;
            }
        }
        public bool FileNummerIsNull
        {
            get
            {
                return _dataRow["FileNummer"] == Convert.DBNull;
            }
        }
        public void FileNummerSetNull()
        {
            _dataRow["FileNummer"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region UseInBanner
        /// <summary>
        /// Moet de thumbnail gebruikt worden op in de banner control
        /// </summary>
        public bool UseInBanner
        {
            get
            {
                return (_dataRow["UseInBanner"] == Convert.DBNull) ? false : Convert.ToBoolean(_dataRow["UseInBanner"]);
            }
            set
            {
                _dataRow["UseInBanner"] = value;
                this.IsDirty = true;
            }
        }
        public bool UseInBannerIsNull
        {
            get
            {
                return _dataRow["UseInBanner"] == Convert.DBNull;
            }
        }
        public void UseInBannerSetNull()
        {
            _dataRow["UseInBanner"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Thumbnail
        /// <summary>
        /// Een thumbnail voor het media bestand
        /// </summary>
        public byte[] Thumbnail
        {
            get
            {
                return (_dataRow["Thumbnail"] == Convert.DBNull) ? null : (byte[])_dataRow["Thumbnail"];
            }
            set
            {
                _dataRow["Thumbnail"] = value;
                this.IsDirty = true;
            }
        }
        public bool ThumbnailIsNull
        {
            get
            {
                return _dataRow["Thumbnail"] == Convert.DBNull;
            }
        }
        public void ThumbnailSetNull()
        {
            _dataRow["Thumbnail"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region CreatedBy
        public String CreatedBy
        {
            get
            {
                return Convert.ToString(_dataRow["CreatedBy"]);
            }
            set
            {
                _dataRow["CreatedBy"] = value;
                this.IsDirty = true;
            }
        }
        #endregion

        #region CreatedAt
        public DateTime CreatedAt
        {
            get
            {
                return Convert.ToDateTime(_dataRow["CreatedAt"]);
            }
            set
            {
                _dataRow["CreatedAt"] = value;
                this.IsDirty = true;
            }
        }
        #endregion

        #region ModifiedBy
        public String ModifiedBy
        {
            get
            {
                return Convert.ToString(_dataRow["ModifiedBy"]);
            }
            set
            {
                _dataRow["ModifiedBy"] = value;
                this.IsDirty = true;
            }
        }
        #endregion

        #region ModifiedAt
        public DateTime ModifiedAt
        {
            get
            {
                return Convert.ToDateTime(_dataRow["ModifiedAt"]);
            }
            set
            {
                _dataRow["ModifiedAt"] = value;
                this.IsDirty = true;
            }
        }
        #endregion

        #region Version
        public int Version
        {
            get
            {
                return _dataRow["Version"] == Convert.DBNull ? -1 : Convert.ToInt32(_dataRow["Version"]);
            }
            set
            {
                _dataRow["Version"] = value;
                this.IsDirty = true;
            }
        }
        #endregion

        #region DigitalInfo
        private DigitalCollection _digitalInfo;
        public DigitalCollection DigitalInfo
        {
            get
            {
                if (_digitalInfo == null && _luw.CanLoad && this.CanLoad && !IdIsNull)
                {
                    _digitalInfo = new DigitalCollection(_luw, BeeldBank.Data.Digital.OpenFromMediaObjectId(Id));
                }
                if (_digitalInfo == null && _luw.CanLoad && this.CanLoad && IdIsNull)
                {
                    _digitalInfo = new DigitalCollection(_luw);
                }
                return _digitalInfo;
            }
        }
        #endregion

        #region OrderRegel
        private OrderRegelCollection _orderRegel;
        public OrderRegelCollection OrderRegel
        {
            get
            {
                if (_orderRegel == null && _luw.CanLoad && this.CanLoad && !IdIsNull)
                {
                    _orderRegel = new OrderRegelCollection(_luw, BeeldBank.Data.OrderRegel.OpenFromMediaId(Id));
                }
                if (_orderRegel == null && _luw.CanLoad && this.CanLoad && IdIsNull)
                {
                    _orderRegel = new OrderRegelCollection(_luw);
                }
                return _orderRegel;
            }
        }
        #endregion

        #region WordItems
        private WordItemCollection _wordItems;
        public WordItemCollection WordItems
        {
            get
            {
                if (_wordItems == null && _luw.CanLoad && this.CanLoad && !IdIsNull)
                {
                    _wordItems = new WordItemCollection(_luw, BeeldBank.Data.WordItem.OpenFromMediaObjectId(Id));
                }
                if (_wordItems == null && _luw.CanLoad && this.CanLoad && IdIsNull)
                {
                    _wordItems = new WordItemCollection(_luw);
                }
                return _wordItems;
            }
        }
        #endregion

        #region Status
        private Status _status;
        public Status Status
        {
            get
            {
                if (_status == null && _luw.CanLoad && this.CanLoad)
                {
                    System.Data.DataTable table = BeeldBank.Data.Status.Open(StatusId);
                    if (table.Rows.Count == 1)
                    {
                        _status = _luw.NewStatus(table.Rows[0]);
                    }
                }
                return _status;
            }
        }
        #endregion

        #region Type
        private Type _type;
        public Type Type
        {
            get
            {
                if (_type == null && _luw.CanLoad && this.CanLoad)
                {
                    System.Data.DataTable table = BeeldBank.Data.Type.Open(TypeId);
                    if (table.Rows.Count == 1)
                    {
                        _type = _luw.NewType(table.Rows[0]);
                    }
                }
                return _type;
            }
        }
        #endregion

        #region Hoogte
        /// <summary>
        /// Hoogte waarop de foto genomen is
        /// </summary>
        public int Hoogte
        {
            get
            {
                return Convert.ToInt32(_dataRow["Hoogte"]);
            }
            set
            {
                _dataRow["Hoogte"] = value;
                this.IsDirty = true;
            }
        }
        public bool HoogteIsNull
        {
            get
            {
                return _dataRow["Hoogte"] == Convert.DBNull;
            }
        }
        public void HoogteSetNull()
        {
            _dataRow["Hoogte"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Longitude
        /// <summary>
        /// Longitude waarop de foto genomen is
        /// </summary>
        public double Longitude
        {
            get
            {
                return Convert.ToDouble(_dataRow["Longitude"]);
            }
            set
            {
                _dataRow["Longitude"] = value;
                this.IsDirty = true;
            }
        }
        public bool LongitudeIsNull
        {
            get
            {
                return _dataRow["Longitude"] == Convert.DBNull;
            }
        }
        public void LongitudeSetNull()
        {
            _dataRow["Longitude"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Latitude
        /// <summary>
        /// Latitude waarop de foto genomen is
        /// </summary>
        public double Latitude
        {
            get
            {
                return Convert.ToDouble(_dataRow["Latitude"]);
            }
            set
            {
                _dataRow["Latitude"] = value;
                this.IsDirty = true;
            }
        }
        public bool LatitudeIsNull
        {
            get
            {
                return _dataRow["Latitude"] == Convert.DBNull;
            }
        }
        public void LatitudeSetNull()
        {
            _dataRow["Latitude"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region Lokatie
        /// <summary>
        /// Lokatie waar de foto genomen is
        /// </summary>
        public string Lokatie
        {
            get
            {
                return (_dataRow["Lokatie"] == Convert.DBNull) ? "" : Convert.ToString(_dataRow["Lokatie"]);
            }
            set
            {
                _dataRow["Lokatie"] = value;
                this.IsDirty = true;
            }
        }
        public bool LokatieIsNull
        {
            get
            {
                return _dataRow["Lokatie"] == Convert.DBNull;
            }
        }
        public void LokatieSetNull()
        {
            _dataRow["Lokatie"] = Convert.DBNull;
            this.IsDirty = true;
        }
        #endregion

        #region ContentChanged
        /// <summary>
        /// ContentChanged
        /// This function checks whether the content of a record is changed, dependant on the "EnforceSave" 
        /// variable. If EnforceSave is false, all the fields which have not been marked "NOTENFORCINGSAVE" as
        /// a stereotype in the design are checked. The contents of the fields are checked against the old values
        /// if they are not equal,the result is true. If the contents are equal, the result is false.
        /// 
        /// If EnforceSave is true, the result is always true.
        /// </summary>
        /// <returns>boolean indicating whether the Content is Changed</returns>
        public bool ContentChanged()
        {
            // Change enforced by Class Variables
            if (this.EnforceSave) { return (true); }
            if (this.IdIsNull) { return (true); }

            // Change enforced by the attributes

            #region Id
            /// Id is excluded because it is the primary key
            #endregion

            #region StatusId

            if (this.StatusIdIsNull != this.OldMediaObject.StatusIdIsNull) { return (true); }
            if (this.StatusId != this.OldMediaObject.StatusId) { return (true); }

            #endregion

            #region TypeId

            if (this.TypeIdIsNull != this.OldMediaObject.TypeIdIsNull) { return (true); }
            if (this.TypeId != this.OldMediaObject.TypeId) { return (true); }

            #endregion

            #region Vervaardiger

            if (this.VervaardigerIsNull != this.OldMediaObject.VervaardigerIsNull) { return (true); }
            if (this.Vervaardiger != this.OldMediaObject.Vervaardiger) { return (true); }

            #endregion

            #region Checked

            if (this.Checked != this.OldMediaObject.Checked) { return (true); }

            #endregion

            #region Titel

            if (this.TitelIsNull != this.OldMediaObject.TitelIsNull) { return (true); }
            if (this.Titel != this.OldMediaObject.Titel) { return (true); }

            #endregion

            #region Omschrijving

            if (this.OmschrijvingIsNull != this.OldMediaObject.OmschrijvingIsNull) { return (true); }
            if (this.Omschrijving != this.OldMediaObject.Omschrijving) { return (true); }

            #endregion

            #region Datum_Realisatie

            if (this.Datum_RealisatieIsNull != this.OldMediaObject.Datum_RealisatieIsNull) { return (true); }
            if (this.Datum_Realisatie != this.OldMediaObject.Datum_Realisatie) { return (true); }

            #endregion

            #region Trefwoorden

            if (this.TrefwoordenIsNull != this.OldMediaObject.TrefwoordenIsNull) { return (true); }
            if (this.Trefwoorden != this.OldMediaObject.Trefwoorden) { return (true); }

            #endregion

            #region FileNummer

            if (this.FileNummerIsNull != this.OldMediaObject.FileNummerIsNull) { return (true); }
            if (this.FileNummer != this.OldMediaObject.FileNummer) { return (true); }

            #endregion

            #region UseInBanner

            if (this.UseInBannerIsNull != this.OldMediaObject.UseInBannerIsNull) { return (true); }
            if (this.UseInBanner != this.OldMediaObject.UseInBanner) { return (true); }

            #endregion

            #region Thumbnail

            if (this.ThumbnailIsNull != this.OldMediaObject.ThumbnailIsNull) { return (true); }
            if (this.Thumbnail != this.OldMediaObject.Thumbnail) { return (true); }

            #endregion

            return false;
        }
        #endregion

        #region WhereAmI
        /// <summary>
        /// Provides the WhereAmI display text for a MediaObject with the specified id
        /// </summary>
        /// <param name="id">Id of the MediaObject.</param>
        /// <return>>WhereAmI display text</returns>
        public static string WhereAmI(int id)
        {
            string whereAmI = "";
            if (id == 0)
            {
                whereAmI = "New MediaObject";
            }
            else
            {
                DataTable table = BeeldBank.Data.MediaObject.Show(id);

                whereAmI = whereAmI + table.Rows[0]["Titel"].ToString();
            }
            return whereAmI;
        }
        #endregion

    }
}
